package com.example.service.impl;

import com.example.mapper.controlTestingMapp;
import com.example.pojo.ThreeList;
import com.example.pojo.assTestLogPojo;
import com.example.pojo.controlPlanPojo;
import com.example.pojo.controlTestingPojo;
import com.example.service.controlTestingService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import javax.print.Doc;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Service//注解：表示把这个注入到了ben中。
@Slf4j//可以输出注解
public class controlTestingImpl implements controlTestingService {
    @Autowired
    controlTestingMapp controlTestingMapp;
    @Value("${file.upload-dir}")
    private String saveDir;
    public List<ThreeList> controlPlanTreeList(){
        //新建一个list，作为返回值，存放目录的信息；
        List<ThreeList>[] lists = new List[3];
        //查询出导航数据所有数据
        List<ThreeList> TreeAll = new ArrayList<>();

        List<String> TreeOne = controlTestingMapp.OneOneStr("workshopEnglish");
        for (int i = 0; i < TreeOne.size(); i++) {
            ThreeList rootOne = new ThreeList(TreeOne.get(i));
            //筛选出二级目录的元素。
            List<String> TreeTow = controlTestingMapp.findDistinctBValuesByA("Drawing", "workshopEnglish", TreeOne.get(i));
            for (int j = 0; j <TreeTow.size() ; j++) {
                //新建一个导航数据结构的列表，用作存储二级目录的数据；
                ThreeList rootTow = new ThreeList(TreeTow.get(j));
                //筛选出三级目录的元素
                List<String> TreeThree =controlTestingMapp.findDistinctBValuesByAandB(
                        "op",
                        "workshopEnglish",
                        TreeOne.get(i),
                        "Drawing",
                        TreeTow.get(j)
                );
                //把筛选出来的三级目录增加到数组中。
                for (int k = 0; k < TreeThree.size(); k++) {
                    //新建一个导航栏结构的列表，存储三级目录的数据信息
                    ThreeList rootThree = new ThreeList();
                    //设置三级数据类别的label的值；
                    rootThree.setLabel("OP"+TreeThree.get(k));
                    //把三级目录添加到整体的目录中，需要添加到二级的Children中
                    rootTow.getChildren().add(rootThree);
                }
                //对数据进行排序
                for (int k = 1; k < rootTow.getChildren().size(); k++) {
                    // 取出需要排序的数据, 先取当前项，一会和前面的对比
                    String subStr2 = rootTow.getChildren().get(k).getLabel();
                    int endIndex2 = subStr2.indexOf("-"); // 查找'-'或字符串末尾
                    if (endIndex2 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                        endIndex2 = subStr2.length();
                    }
                    int subNum2 = Integer.parseInt(subStr2.substring(2, endIndex2)); // 假设索引从2开始取数字

                    // 循环和前面的对比
                    for (int l = k; l > 0; l--) { // 注意这里l > 0
                        // 取出前面的项
                        String subStr1 = rootTow.getChildren().get(l - 1).getLabel();
                        int endIndex1 = subStr1.indexOf("-"); // 查找'-'或字符串末尾
                        if (endIndex1 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                            endIndex1 = subStr1.length();
                        }
                        int subNum1 = Integer.parseInt(subStr1.substring(2, endIndex1)); // 假设索引从2开始取数字

                        // 对比两个数
                        if (subNum1 > subNum2) {
                            // 需要交换位置
                            ThreeList temp = rootTow.getChildren().get(l - 1); // 获取前面的项
                            rootTow.getChildren().set(l - 1, rootTow.getChildren().get(l)); // 将当前项放到前面项的位置
                            rootTow.getChildren().set(l, temp); // 将前面项放到当前项的位置，完成交换
                        } else {
                            // 如果subNum1不大于subNum2，则无需继续向前比较，因为前面的项已经是有序的
                            break;
                        }
                    }
                }
                //把二级目录添加到整体目录中，需要添加到一级的Children中
                rootOne.getChildren().add(rootTow);
            }
            TreeAll.add(rootOne);
        }
        //把英文的列表记录下来
        lists[0]=TreeAll;
        //查询出中文的导航数据
        TreeOne = controlTestingMapp.OneOneStr("workshop");
        for (int i = 0; i < TreeOne.size(); i++) {
            ThreeList rootOne = new ThreeList(TreeOne.get(i));
            //筛选出二级目录的元素。
            List<String> TreeTow = controlTestingMapp.findDistinctBValuesByA("Drawing", "workshop", TreeOne.get(i));
            for (int j = 0; j <TreeTow.size() ; j++) {
                //新建一个导航数据结构的列表，用作存储二级目录的数据；
                ThreeList rootTow = new ThreeList(TreeTow.get(j));
                //筛选出三级目录的元素
                List<String> TreeThree =controlTestingMapp.findDistinctBValuesByAandB(
                        "op",
                        "workshop",
                        TreeOne.get(i),
                        "Drawing",
                        TreeTow.get(j)
                );
                //把筛选出来的三级目录增加到数组中。
                for (int k = 0; k < TreeThree.size(); k++) {
                    //新建一个导航栏结构的列表，存储三级目录的数据信息
                    ThreeList rootThree = new ThreeList();
                    //设置三级数据类别的label的值；
                    rootThree.setLabel("OP"+TreeThree.get(k));
                    //把三级目录添加到整体的目录中，需要添加到二级的Children中
                    rootTow.getChildren().add(rootThree);
                }
                //对数据进行排序
                for (int k = 1; k < rootTow.getChildren().size(); k++) {
                    // 取出需要排序的数据, 先取当前项，一会和前面的对比
                    String subStr2 = rootTow.getChildren().get(k).getLabel();
                    int endIndex2 = subStr2.indexOf("-"); // 查找'-'或字符串末尾
                    if (endIndex2 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                        endIndex2 = subStr2.length();
                    }
                    int subNum2 = Integer.parseInt(subStr2.substring(2, endIndex2)); // 假设索引从2开始取数字

                    // 循环和前面的对比
                    for (int l = k; l > 0; l--) { // 注意这里l > 0
                        // 取出前面的项
                        String subStr1 = rootTow.getChildren().get(l - 1).getLabel();
                        int endIndex1 = subStr1.indexOf("-"); // 查找'-'或字符串末尾
                        if (endIndex1 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                            endIndex1 = subStr1.length();
                        }
                        int subNum1 = Integer.parseInt(subStr1.substring(2, endIndex1)); // 假设索引从2开始取数字

                        // 对比两个数
                        if (subNum1 > subNum2) {
                            // 需要交换位置
                            ThreeList temp = rootTow.getChildren().get(l - 1); // 获取前面的项
                            rootTow.getChildren().set(l - 1, rootTow.getChildren().get(l)); // 将当前项放到前面项的位置
                            rootTow.getChildren().set(l, temp); // 将前面项放到当前项的位置，完成交换
                        } else {
                            // 如果subNum1不大于subNum2，则无需继续向前比较，因为前面的项已经是有序的
                            break;
                        }
                    }
                }
                //把二级目录添加到整体目录中，需要添加到一级的Children中
                rootOne.getChildren().add(rootTow);
            }
            TreeAll.add(rootOne);
        }
        //把中文的列表记录下来
        lists[1]=TreeAll;
//        //查询出俄语的导航数据
        TreeOne = controlTestingMapp.OneOneStr("workshopRussian");
        for (int i = 0; i < TreeOne.size(); i++) {
            ThreeList rootOne = new ThreeList(TreeOne.get(i));
            //筛选出二级目录的元素。
            List<String> TreeTow = controlTestingMapp.findDistinctBValuesByA("Drawing", "workshopRussian", TreeOne.get(i));
            for (int j = 0; j <TreeTow.size() ; j++) {
                //新建一个导航数据结构的列表，用作存储二级目录的数据；
                ThreeList rootTow = new ThreeList(TreeTow.get(j));
                //筛选出三级目录的元素
                List<String> TreeThree =controlTestingMapp.findDistinctBValuesByAandB(
                        "op",
                        "workshopRussian",
                        TreeOne.get(i),
                        "Drawing",
                        TreeTow.get(j)
                );
                //把筛选出来的三级目录增加到数组中。
                for (int k = 0; k < TreeThree.size(); k++) {
                    //新建一个导航栏结构的列表，存储三级目录的数据信息
                    ThreeList rootThree = new ThreeList();
                    //设置三级数据类别的label的值；
                    rootThree.setLabel("OP"+TreeThree.get(k));
                    //把三级目录添加到整体的目录中，需要添加到二级的Children中
                    rootTow.getChildren().add(rootThree);
                }
                //对数据进行排序
                for (int k = 1; k < rootTow.getChildren().size(); k++) {
                    // 取出需要排序的数据, 先取当前项，一会和前面的对比
                    String subStr2 = rootTow.getChildren().get(k).getLabel();
                    int endIndex2 = subStr2.indexOf("-"); // 查找'-'或字符串末尾
                    if (endIndex2 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                        endIndex2 = subStr2.length();
                    }
                    int subNum2 = Integer.parseInt(subStr2.substring(2, endIndex2)); // 假设索引从2开始取数字

                    // 循环和前面的对比
                    for (int l = k; l > 0; l--) { // 注意这里l > 0
                        // 取出前面的项
                        String subStr1 = rootTow.getChildren().get(l - 1).getLabel();
                        int endIndex1 = subStr1.indexOf("-"); // 查找'-'或字符串末尾
                        if (endIndex1 == -1) { // 如果没有找到'-'，则使用字符串长度作为结束索引
                            endIndex1 = subStr1.length();
                        }
                        int subNum1 = Integer.parseInt(subStr1.substring(2, endIndex1)); // 假设索引从2开始取数字

                        // 对比两个数
                        if (subNum1 > subNum2) {
                            // 需要交换位置
                            ThreeList temp = rootTow.getChildren().get(l - 1); // 获取前面的项
                            rootTow.getChildren().set(l - 1, rootTow.getChildren().get(l)); // 将当前项放到前面项的位置
                            rootTow.getChildren().set(l, temp); // 将前面项放到当前项的位置，完成交换
                        } else {
                            // 如果subNum1不大于subNum2，则无需继续向前比较，因为前面的项已经是有序的
                            break;
                        }
                    }
                }
                //把二级目录添加到整体目录中，需要添加到一级的Children中
                rootOne.getChildren().add(rootTow);
            }
            TreeAll.add(rootOne);
        }
//        //把俄文的列表记录下来
        lists[2]=TreeAll;
        System.out.println(TreeAll);
        return TreeAll;
    }
    //根据传来的控制计划标记位查询数据
    public List<controlTestingPojo> controlTestingListByclickId(controlTestingPojo controlTesting){
        //更改记录的对应的数据，查询所有列
        List<controlTestingPojo> controlTestingPojoList=controlTestingMapp.allByOneTesting(controlTesting);
        return controlTestingPojoList;
    }

    //点击树形结构，把对应该序的数据均筛选出来
    public List<controlTestingPojo> controlTestingList(controlTestingPojo controlTestingPojo){
        List<controlTestingPojo> controlTestingPojoList=controlTestingMapp.controlTestingList(controlTestingPojo);
        return controlTestingPojoList;
    }

    //新的数据库下使用
    //点击导航，进行查询的函数,根据工序号进行查询
    public List<controlTestingPojo> inquiryControlTestingByOp(Map<String, Object> parameters){
        String firstFieldName=(String) parameters.get("firstFieldName");
        String firstFieldVal=(String) parameters.get("firstFieldVal");
        String secondFieldName=(String) parameters.get("secondFieldName");
        String secondFieldVal=(String) parameters.get("secondFieldVal");
        String thirdFieldName=(String) parameters.get("thirdFieldName");
        String thirdFieldVal=(String) parameters.get("thirdFieldVal");
        List<controlTestingPojo> controlTestingPojoList=controlTestingMapp.strFieldThree(firstFieldName,firstFieldVal,secondFieldName,secondFieldVal,thirdFieldName,thirdFieldVal);
        return controlTestingPojoList;
    }
    //保存用户输入的检测数据
    public void testingValInsert(List<controlTestingPojo> controlTestingPojoList){
        for (int i = 0; i < controlTestingPojoList.size(); i++) {
            //组合创建时间
            controlTestingPojoList.get(i).setEstablishTime(LocalDateTime.now());
            //组合修改时间
            controlTestingPojoList.get(i).setUpdateTime(LocalDateTime.now());
            controlTestingMapp.testingValInsert(controlTestingPojoList.get(i));
        }
    }
    //筛选出用户做趋势图的数据
    public List<controlTestingPojo> selectNum(controlTestingPojo controlTestingPojo){
        List<controlTestingPojo> controlTestingPojoList=controlTestingMapp.selectNum(controlTestingPojo);
        return controlTestingPojoList;
    }
    //在更正数据页面中，修改数据，接收的是修数字信息
    public void testingEditNmb(Map<String, Object> parameters){
        Integer idUse = (Integer) parameters.get("idUse");
        String field = (String) parameters.get("field");

        double val = Double.parseDouble((String) parameters.get("val"));
        //组合修改时间
        LocalDateTime dateTime=LocalDateTime.now();
        controlTestingMapp.testingEditNmb(idUse,field,val,dateTime);
    }
    //在更正数据页面中，修改数据，接收的是修改文本信息
    public void testingEditStr(Map<String, Object> parameters){
        Integer idUse = (Integer) parameters.get("idUse");
        String field = (String) parameters.get("field");
        String val = (String) parameters.get("val");
        LocalDateTime dateTime=LocalDateTime.now();
        controlTestingMapp.testingEditStr(idUse,field,val,dateTime);
    }
    //给控制计划管理页面查询“频次检测”的信息，只筛选控制计划标记位的内容
    public List<controlTestingPojo> controlByclickId(controlTestingPojo controlTesting){
        List<controlTestingPojo> controlTestingPojoList=controlTestingMapp.controlByclickId(controlTesting);
        return controlTestingPojoList;
    }
    //根据ID修改数据
    public void putById(controlTestingPojo controlTestingPojo){
        //组合修改时间
        controlTestingPojo.setUpdateTime(LocalDateTime.now());
        //调用接口进行修改数据
        controlTestingMapp.putById(controlTestingPojo);
    }
    //接收到前端的向下插入或者向上插入指令，开始向数据库中插入，接收到的是一个List
    public void controlTestingInsertC(List<controlTestingPojo> controlTestingPojoList){
        //循环，逐个对数据列表进行操作。
        int id=-1;
        for (int i = 0; i < controlTestingPojoList.size(); i++) {
            if (controlTestingPojoList.get(i).getId()==-1){
                //插入本行，并记录下索引号
                controlTestingPojoList.get(i).setUpdateTime(LocalDateTime.now());//组合修改时间
                controlTestingPojoList.get(i).setEstablishTime(LocalDateTime.now());//组合创建时间
                controlTestingMapp.InsertOne(controlTestingPojoList.get(i));
                id=i;
                break;
            }
        }

        //对其他的进行修改
        for (int i = id; i < controlTestingPojoList.size(); i++) {
            //原有数据，执行修改
            controlTestingPojoList.get(i).setUpdateTime(LocalDateTime.now());//组合修改时间
            controlTestingMapp.putById(controlTestingPojoList.get(i));
        }
    }
    //根据ID，修改检测基准表中的某一个字段的值
    public void editOneFiledByControlTestingNew(Map<String, Object> parameters){
        Integer id= (Integer) parameters.get("id");
        String field=(String) parameters.get("field");
        String val=(String) parameters.get("val");
        LocalDateTime dateTime = LocalDateTime.now();
        controlTestingMapp.editOneFiledByControlTestingNew(id,field,val,dateTime);
    }
    //上传照片的实现类
    public String addPicture(MultipartFile file, Integer id, String fieldName, String fieldVal, String fileName){
        try {
            if (!file.isEmpty()) {
                String filePath = saveDir + fileName;
                File dest = new File(filePath);
                // 将文件保存到服务器上的指定位置
                file.transferTo(dest);
                // 将新的作业指导书内容写入到数据库中
                LocalDateTime dateTime = LocalDateTime.now();
                //根据传来的作业指导书内容，写入到数据库中
                controlTestingMapp.editOneFiledByControlTestingNew(id, fieldName, fieldVal, dateTime);
            }
        }
        catch (IOException e) {
            // 捕获异常并返回错误消息
            throw new RuntimeException("文件保存失败：" + e.getMessage());
        }
        return fieldVal;
    }
    //下载图片、视频
     public byte[] readFile(String fileName){
         File file = new File(saveDir + fileName);
         // 检查文件是否存在且可读
         if (file.exists() && file.canRead()) {
             try (FileInputStream fis = new FileInputStream(file)) {
                 // 读取文件内容到byte[]数组中
                 byte[] fileContent = fis.readAllBytes();
                 return fileContent; // 返回文件内容的byte[]数组
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         // 如果文件不存在或不可读，或者读取时发生异常，返回null
         System.out.println("文件不存在或不可读：" + file.getAbsolutePath());
         return null;
     }
     //删除图片、视频
    public String PictureRemove(Map<String, Object> parameters){
        Integer id=(Integer) parameters.get("id");
        String fieldName=(String) parameters.get("fieldName");
        String filedVal=(String) parameters.get("filedVal");
        String pictureName=(String) parameters.get("pictureName");
        //删除文件
        String filePath =saveDir+pictureName; // 替换为你的文件路径
        // 使用 Paths 类的静态方法 get 来根据给定的文件路径字符串 filePath 创建一个 Path 对象
        Path path = Paths.get(filePath);
        try {
            //先把数据库的信息修改掉
            LocalDateTime dateTime = LocalDateTime.now();
            //修改数据库
            // 将数据写入到数据库中
            controlTestingMapp.editOneFiledByControlTestingNew(id, fieldName, filedVal, dateTime);
            // 使用 Files 类的 delete 方法删除指定的文件
            Files.delete(path);
            return filedVal;
        }
        catch (IOException e) {
            System.err.println("删除文件时出错: " + e.getMessage());
            return "删除文件时出错";
        }
    }
    //根据传来的字段(机型号），查询共计有多少条
    public int queryNumControlTexting(String filed){
        int mum=controlTestingMapp.queryNumControlTexting(filed);
        return mum;
    }
    //向检测数据库中的数据进行查询，是输入一个字段名，以及值，符合这一原则的数量是多少
    public int queryNumTextingResult(Map<String, Object> map){
        String fieldName=(String) map.get("fieldName");
        String fieldVal=(String) map.get("fieldVal");
        int num=controlTestingMapp.queryNumTextingResult(fieldName,fieldVal);
        return num;
    }
    //依据两个字段，向后端查询装配检测日志的信息
    public assTestLogPojo assTestLogInquiryByTowFiled(Map<String, Object> map){
        String oneFiledName=(String) map.get("oneFiledName");
        String oneFiledVal=(String) map.get("oneFiledVal");
        String towFiledNane=(String) map.get("towFiledNane");
        String towFiledVal=(String) map.get("towFiledVal");
        assTestLogPojo assTestLogPojo=controlTestingMapp.assTestLogInquiryByTowFiled(oneFiledName,oneFiledVal,towFiledNane,towFiledVal);
        return assTestLogPojo;
    }
    //向装配检测日志的数据库中查询，根据一个字段（数据不唯一）
    public List<assTestLogPojo> assTestLogInquiryByOneFiled(Map<String, Object> map){
        String oneFiledName=(String) map.get("oneFiledName");
        String oneFiledVal=(String) map.get("oneFiledVal");
        List<assTestLogPojo> assTestLogPojos=controlTestingMapp.assTestLogInquiryByOneFiled(oneFiledName,oneFiledVal);
        return assTestLogPojos;
    }
    //辅助函数：（检测标准）根据一个字段，查询出符合这个字段所有的数据
    public List<controlTestingPojo> controlTestingInquiryOneFiled(Map<String, Object> map){
        String oneFiledName=(String) map.get("oneFiledName");
        String oneFiledVal=(String) map.get("oneFiledVal");
        System.out.println(oneFiledName);
        System.out.println(oneFiledVal);
        List<controlTestingPojo> pojos=controlTestingMapp.controlTestingInquiryOneFiled(oneFiledName,oneFiledVal);
        return pojos;
    }
    //辅助函数：（检测结果）根据三个字段，询符合等于这三个字段的数据
    public List<controlTestingPojo> controlTestingDataInquiryThreeFiled(Map<String, Object> map){
        String oneFiledName=(String) map.get("oneFiledName");
        String oneFiledVal=(String) map.get("oneFiledVal");
        String towFiledNane=(String) map.get("towFiledNane");
        String towFiledVal=(String) map.get("towFiledVal");
        String threeFiledName=(String) map.get("threeFiledName");
        String threeFiledVal=(String) map.get("threeFiledVal");
        List<controlTestingPojo> controlTestingPojoList=controlTestingMapp.controlTestingDataInquiryThreeFiled(
                oneFiledName,oneFiledVal,
                towFiledNane,towFiledVal,
                threeFiledName,threeFiledVal
        );
        return controlTestingPojoList;
    }
    //辅助函数，(检测日志）向装配检测日志的数据库中一次插入多个数据
    public void assTestLogInsertAll(List<assTestLogPojo> assTestLogPojoList){
// 定义每批的数量
        int batchSize = 300;
        // 计算需要的批次数量
        int totalBatches = (int) Math.ceil((double) assTestLogPojoList.size() / batchSize);
        // 遍历每个批次
        for (int i = 0; i < totalBatches; i++) {
            // 计算当前批次的起始和结束索引
            int startIndex = i * batchSize;
            int endIndex = Math.min(startIndex + batchSize, assTestLogPojoList.size());
            // 创建当前批次的数据列表
            List<assTestLogPojo> batchList = new ArrayList<>(assTestLogPojoList.subList(startIndex, endIndex));
            // 给时间字段赋值
            for (assTestLogPojo pojo : batchList) {
                pojo.setUpdateTime(LocalDateTime.now());
                pojo.setEstablishTime(LocalDateTime.now());
            }
            // 调用Mapper方法插入当前批次的数据
            controlTestingMapp.assTestLogInsertAll(batchList);
        }
    }
    //辅助函数：（检测日志）根据一个字段，按照另一个字段从大到小排序，查询出第一条（主要用在了查询最后计算日期的场景上）
    public assTestLogPojo assTestLogEndDateCount(Map<String, Object> map){
        String oneFiledName=(String) map.get("oneFiledName");
        String oneFieldVal=(String) map.get("oneFieldVal");
        String towFieldName=(String) map.get("towFieldName");
        assTestLogPojo assTestLogPojo=controlTestingMapp.assTestLogEndDateCount(oneFiledName,oneFieldVal,towFieldName);
        return assTestLogPojo;
    }
    //辅助函数：（检测数据）根据一个字段，查询这个字段下A值到B值的数据，主要用在查询两个日期之间的值，或者大于A，小于等于B的值；
    public List<controlTestingPojo> queryOneFieldByAtoB(Map<String, Object> map){
        String fieldName=(String) map.get("fieldName");
        String fieldValA=(String) map.get("fieldValA");
        String fieldValB=(String) map.get("fieldValB");
        String towFieldName=(String) map.get("towFieldName");
        String towFieldVal=(String) map.get("towFieldVal");
        List<controlTestingPojo> controlTestingPojoList=controlTestingMapp.queryOneFieldByAtoB(fieldName,fieldValA,fieldValB,towFieldName,towFieldVal);
        return controlTestingPojoList;
    }
    //辅助函数：（检测数据）根据一个字段A等于某一值，B字段从大到小排序，筛选n行；
    public List<controlTestingPojo> testingQueryFieldAndBNum(Map<String, Object> map){
        String fieldNameA=(String) map.get("fieldNameA");
        String fieldValA=(String) map.get("fieldValA");
        String fieldNameB=(String) map.get("fieldNameB");
        String startData=(String) map.get("startData");
        int n=(int) map.get("n");
        List<controlTestingPojo> controlTestingPojos=controlTestingMapp.testingQueryFieldAndBNum(fieldNameA,fieldValA,fieldNameB,n,startData);
        return controlTestingPojos;
    }
    //(检测日志)根据用户点击的刷新按钮，更新最新的计算日期：type是类型，例如：EB05PPK，或者其他的类型数据，doe:是检测类型中的第二位，例如，EB05PPK，M，就是代表要查询月度EB05PPK的值，也就是模糊查询EB05PPK-M，排序是dateUse列创建时间倒序排序；
    public assTestLogPojo assTestLogRefreshPPKDate(Map<String, Object> map){
        String FiledVal=(String) map.get("FiledVal");
        assTestLogPojo assTestLogPojo=controlTestingMapp.assTestLogRefreshPPKDate(FiledVal);
        return assTestLogPojo;
    }
    //辅助函数：（检测数据）根据一个字段，查询等于这个字段的所有数据
    public List<controlTestingPojo> testingQueryOneFiled(Map<String, Object> map){
        String fieldName=(String) map.get("fieldName");
        String fieldVal=(String) map.get("fieldVal");
        List<controlTestingPojo> controlTestingPojoList=controlTestingMapp.testingQueryOneFiled(fieldName,fieldVal);
        return controlTestingPojoList;
    }
}
